﻿using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;

namespace Teal.Compiler {

    #region MemberReference

    /// <summary>
    /// 表示一个成员（如方法、字段、类型、包等）引用。
    /// </summary>
    public abstract partial class MemberReference {

        #region 暂时不能删除

        /// <summary>
        /// 获取当前成员的标记位。
        /// </summary>
        public ResolveFlags resolveFlags;

        #endregion

        #region 树结构

        /// <summary>
        /// 支持多个对象组成一个单链表。
        /// </summary>
        public MemberReference next;

        /// <summary>
        /// 获取包含此成员的容器。
        /// </summary>
        public NamespaceReference container;

        /// <summary>
        /// 获取包含此成员的容器类型。如果父容器不是类型，则返回 null。
        /// </summary>
        public TypeReference containerType {
            get {
                return container as TypeReference;
            }
            set {
                container = value;
            }
        }

        /// <summary>
        /// 获取包含此成员的容器模块。
        /// </summary>
        public ModuleReference containerModule {
            get {
                for (var c = container; c != null; c = c.container) {
                    var p = c as ModuleReference;
                    if (p != null) {
                        return p;
                    }
                }
                return null;
            }
        }

        /// <summary>
        /// 判断当前成员是否是指定容器的内嵌成员。
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public bool isNestedChildOf(NamespaceReference other) {
            for (var c = this; c != null; c = c.container) {
                if (c == other) {
                    return true;
                }
            }
            return false;
        }

        #endregion

        #region 注解

        /// <summary>
        /// 表示一个注解引用。
        /// </summary>
        public partial class MemberAnnotation {

        }

        /// <summary>
        /// 获取当前成员的所有注解。
        /// </summary>
        Dictionary<TypeReference, MemberAnnotation> _annotations;

        /// <summary>
        /// 获取当前成员的指定内置注解。
        /// </summary>
        /// <param name="annotationType">要获取的内置注解类型。</param>
        /// <returns>包含此内置注解的数据。</returns>
        public MemberAnnotation getAnnotation(TypeReference annotationType) {

            if (_annotations == null) {
                _annotations = new Dictionary<TypeReference, MemberAnnotation>();
            }

            MemberAnnotation result;
            if (_annotations.TryGetValue(annotationType, out result)) {
                return result;
            }

            // 从源获取最新的注解数据。
            return _annotations[annotationType] = loadAnnotation(annotationType);
        }

        /// <summary>
        /// 当被子类重写时，负责导入注解。
        /// </summary>
        /// <param name="annotationType">要获取的内置注解类型。</param>
        /// <returns>包含此内置注解的数据。</returns>
        protected virtual MemberAnnotation loadAnnotation(TypeReference annotationType) {
            if (definition == null) {
                return null;
            }
            // definition.getAnnotation(annotationType);
            return null;
        }

        #endregion

        #region 名字

        /// <summary>
        /// 获取当前成员的名字。
        /// </summary>
        public string name;

        /// <summary>
        /// 获取当前成员的签名。
        /// </summary>
        public string signature {
            get {
                StringBuilder buffer = new StringBuilder(24);
                writeSignature(buffer);
                return buffer.ToString();
            }
        }

        /// <summary>
        /// 将当前成员的签名写入字符串缓存。
        /// </summary>
        /// <param name="buffer">用于写入的缓冲区对象。</param>
        public virtual void writeSignature(StringBuilder buffer) {
            if (container != null && container.name != null) {
                container.writeSignature(buffer);
                buffer.Append('.');
            }
            buffer.Append(name);
        }

        /// <summary>
        /// 返回表示当前对象的字符串。
        /// </summary>
        /// <returns>表示当前对象的字符串。</returns>
        public override string ToString() {
            return signature;
        }

        #endregion

        #region 泛型

        /// <summary>
        /// 获取当前成员的泛型定义。如果当前成员不是泛型定义，则返回自身。
        /// </summary>
        public virtual MemberReference genericDefinition {
            get {
                return this;
            }
        }

        /// <summary>
        /// 表示一个泛型参数引用。
        /// </summary>
        public partial class GenericParameter : TypeReference {

            /// <summary>
            /// 将当前成员的签名写入字符串缓存。
            /// </summary>
            /// <param name="buffer">用于写入的缓冲区对象。</param>
            public override void writeSignature(StringBuilder buffer) {
                buffer.Append(name);
            }

            /// <summary>
            /// 表示泛型形参的属性。
            /// </summary>
            public enum Attributes {

                /// <summary>
                /// 指示当前泛型参数约束为类。
                /// </summary>
                classConstraint = 1 << 0,

                /// <summary>
                /// 指示当前泛型参数约束为结构。
                /// </summary>
                structConstraint = 1 << 1,

                /// <summary>
                /// 指示当前泛型参数约束为枚举。
                /// </summary>
                enumConstraint = 1 << 2,

                /// <summary>
                /// 指示当前泛型参数约束为指定成员类型。
                /// </summary>
                MEMBER_TYPE_CONSTRAINT = classConstraint | structConstraint | enumConstraint,

                /// <summary>
                /// 指示当前泛型参数约束需要默认构造函数。
                /// </summary>
                defaultConstructorConstraint = 1 << 3

            }

            /// <summary>
            /// 获取当前形参的属性。
            /// </summary>
            public Attributes attributes;

            /// <summary>
            /// 判断当前泛型约束是否约束为指定类型。
            /// </summary>
            public bool hasConstraints {
                get {
                    return attributes == 0 && baseClass != PredefinedTypes.System_Object;
                }
            }

            /// <summary>
            /// 判断当前泛型参数是否约束为 new() 。
            /// </summary>
            public bool hasDefaultConstructorConstraint {
                get {
                    return (attributes & Attributes.defaultConstructorConstraint) != 0;
                }
            }

            /// <summary>
            /// 获取当前泛型形参的约束成员类型。
            /// </summary>
            public Attributes memberTypeConstraint {
                get {
                    return attributes & Attributes.MEMBER_TYPE_CONSTRAINT;
                }
            }

            /// <summary>
            /// 获取当前泛型参数在所属泛型定义的形参列表索引。
            /// </summary>
            public int index;

            /// <summary>
            /// 获取当前参数所属的成员定义。
            /// </summary>
            public MemberReference containerDefinitionMember;

            /// <summary>
            /// 初始化 <see cref="GenericParameter"/> 类的新实例。
            /// </summary>
            public GenericParameter()
                : base(MemberType.typeParameter) { }

            /// <summary>
            /// 填充当前成员相关的泛型并返回新类型。
            /// </summary>
            /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
            /// <returns>返回填充后的新成员。</returns>
            public override MemberReference inflateMember(MemberReference genericMember) {
                //
                // class A<T> {
                //   class B<U:List<T>> {}
                // }
                //
                // 生成 A<int> 时会调用 U.inflateMember([int])
                var result = (MemberReference.GenericParameter)MemberwiseClone();
                // 扩展约束。
                Debug.Assert(baseClass != null, "泛型形参的基类为空？");
                result.baseClass = baseClass.inflate(genericMember);
                if (baseInterfaces != null) {
                    result.baseInterfaces = new List<TypeReference>(baseInterfaces.Count);
                    for (int i = 0; i < result.baseInterfaces.Count; i++) {
                        result.baseInterfaces[i] = baseInterfaces[i].inflate(genericMember);
                    }
                }
                return result;
            }

            /// <summary>
            /// 应用指定的泛型实参以替换当前类型。
            /// </summary>
            /// <param name="genericMember">引发本次操作的泛型。</param>
            /// <returns>返回替换的类型。</returns>
            public override TypeReference inflate(MemberReference genericMember) {

                // 泛型参数 T 可能属于当前填充的泛型或其父类型。
                do {
                    if (genericMember.genericDefinition == containerDefinitionMember) {
                        return genericMember.genericArguments[index];
                    }
                } while ((genericMember = genericMember.container) != null);

                return this;
            }

            /// <summary>
            /// 检查指定的类型是否可用于替换当前泛型形参。
            /// </summary>
            /// <param name="type">要检查的泛型实参。</param>
            /// <param name="srcNode">引发本次操作的源节点，主要用于报错。</param>
            public void checkConstraint(TypeReference type, Expression srcNode) {

                // 检查成员类型约束。
                switch (memberTypeConstraint) {
                    case 0:
                        break;
                    case Attributes.classConstraint:
                        if (type.memberType != MemberType.@class) {
                            Compiler.error(ErrorCode.none, "不符合 class 约束", srcNode);
                        }
                        break;
                    case Attributes.structConstraint:
                        if (type.memberType != MemberType.@struct) {
                            Compiler.error(ErrorCode.none, "不符合 struct 约束", srcNode);
                        }
                        break;
                    case Attributes.enumConstraint:
                        if (type.memberType != MemberType.@enum) {
                            Compiler.error(ErrorCode.none, "不符合 enum 约束", srcNode);
                        }
                        break;
                }

                // 检查基类约束。
                if (baseClass != PredefinedTypes.System_Object) {

                }

                // 检查基接口约束。
                if (baseInterfaces != null) {
                    foreach (var baseInterface in baseInterfaces) {

                    }
                }

                // 检查默认构造函数约束。
                if (hasDefaultConstructorConstraint) {

                }

            }

            //bool CheckConversion(IMemberContext mc, MemberReference context, TypeReference atype, Teal.Compiler.MemberReference.GenericParameter tparam, TypeReference ttype, Location2 loc) {
            //    if (atype == ttype)
            //        return true;

            //    if (atype.IsGenericParameter) {
            //        var tps = (Teal.Compiler.MemberReference.GenericParameter)atype;
            //        if (tps.HasDependencyOn(ttype))
            //            return true;

            //        if (Convert.ImplicitTypeParameterConversion(null, tps, ttype) != null)
            //            return true;

            //    } else if (TypeReference.IsValueType(atype)) {
            //        if (atype.IsNullableType) {
            //            //
            //            // LAMESPEC: Only identity or base type ValueType or Object satisfy nullable type
            //            //
            //            if (TypeReference.IsBaseClass(atype, ttype, false))
            //                return true;
            //        } else {
            //            if (Convert.ImplicitBoxingConversion(null, atype, ttype) != null)
            //                return true;
            //        }
            //    } else {
            //        if (Convert.ImplicitReferenceConversionExists(atype, ttype) || Convert.ImplicitBoxingConversion(null, atype, ttype) != null)
            //            return true;
            //    }

            //    if (mc != null) {
            //        Compiler.Report.SymbolRelatedToPreviousError(tparam);
            //        if (atype.IsGenericParameter) {
            //            Compiler.Report.Error(314, loc,
            //                "The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. There is no boxing or type parameter conversion from `{0}' to `{3}'",
            //                atype.GetSignatureForError(), tparam.GetSignatureForError(), context.GetSignatureForError(), ttype.GetSignatureForError());
            //        } else if (TypeReference.IsValueType(atype)) {
            //            Compiler.Report.Error(315, loc,
            //                "The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. There is no boxing conversion from `{0}' to `{3}'",
            //                atype.GetSignatureForError(), tparam.GetSignatureForError(), context.GetSignatureForError(), ttype.GetSignatureForError());
            //        } else {
            //            Compiler.Report.Error(311, loc,
            //                "The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. There is no implicit reference conversion from `{0}' to `{3}'",
            //                atype.GetSignatureForError(), tparam.GetSignatureForError(), context.GetSignatureForError(), ttype.GetSignatureForError());
            //        }
            //    }

            //    return false;
            //}

            //static bool HasDefaultConstructor(TypeReference atype) {
            //    var tp = atype as Teal.Compiler.MemberReference.GenericParameter;
            //    if (tp != null) {
            //        return tp.HasSpecialConstructor || tp.HasSpecialStruct;
            //    }

            //    if (atype.IsStruct || atype.IsEnum)
            //        return true;

            //    if (atype.IsAbstract)
            //        return false;

            //    var tdef = atype.GetDefinition();

            //    var found = MemberCache.FindMember(tdef,
            //        MemberFilter.Constructor(ParametersCompiled.EmptyReadOnlyParameters),
            //        BindingRestriction.DeclaredOnly | BindingRestriction.InstanceOnly);

            //    return found != null && (found.modifiers & Modifiers.@public) != 0;
            //}
        }

        /// <summary>
        /// 获取当前成员的泛型形参。
        /// </summary>
        public virtual GenericParameter[] genericParameters {
            get {
                return null;
            }
        }

        /// <summary>
        /// 获取当前成员的泛型实参。
        /// </summary>
        public virtual TypeReference[] genericArguments {
            get {
                return null;
            }
        }

        /// <summary>
        /// 获取当前成员引用的泛型定义参数个数。如果当前成员不是泛型定义，则返回 0。
        /// </summary>
        public int genericParameterCount {
            get {
                var ps = genericParameters;
                return ps == null ? 0 : ps.Length;
            }
        }

        /// <summary>
        /// 获取指定名字的泛型形参。如果不存在则返回 null 。
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public GenericParameter getGenericParameter(string name) {
            var ps = genericParameters;
            if (ps != null) {
                foreach (var p in ps) {
                    if (p.name == name) {
                        return p;
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// 判断两个成员是否具有相同数目的泛型形参。
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public bool hasSameGenericParameterCount(MemberReference other) {
            return genericParameters == null ? other.genericParameters == null :
                 (other.genericParameters != null && genericParameters.Length == other.genericParameters.Length);
        }

        /// <summary>
        /// 判断当前成员是否可在具有指定泛型实参时使用。
        /// </summary>
        /// <param name="genericArgumentCount"></param>
        /// <returns></returns>
        public bool matchGenericArgumentCount(int genericArgumentCount) {
            return genericArgumentCount == 0 ? memberType == MemberType.method || genericParameters == null : (genericParameters != null && (genericParameters.Length == genericArgumentCount || genericParameters == PredefinedTypes.argListParameters));
        }

        /// <summary>
        /// 判断当前成员是泛型定义。
        /// </summary>
        public bool isGenericDefinition {
            get {
                var t = this;
                do {
                    if (t.genericParameters != null)
                        return true;
                    t = t.containerType;
                } while (t != null);
                return false;
            }
        }

        /// <summary>
        /// 判断当前成员是否是泛型定义或泛型实例。
        /// </summary>
        public bool isGeneric {
            get {
                var t = this;
                do {
                    if (t.genericDefinition != t)
                        return true;
                    t = t.containerType;
                } while (t != null);
                return false;
            }
        }

        /// <summary>
        /// 替换当前成员依赖的所有泛型形参并返回替换后的新成员。
        /// </summary>
        /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
        /// <returns>返回替换后的新成员。</returns>
        public abstract MemberReference inflateMember(MemberReference genericMember);

        /// <summary>
        /// 替换所有泛型形参依赖的所有泛型形参并返回替换后的新成员。
        /// </summary>
        /// <param name="genericParameters">要替换的参数。</param>
        /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
        /// <returns>返回替换后的新成员。</returns>
        protected static GenericParameter[] inflateGenericParameters(GenericParameter[] genericParameters, MemberReference genericMember) {
            var result = new GenericParameter[genericParameters.Length];
            for (var i = 0; i < result.Length; i++) {
                result[i] = (GenericParameter)genericParameters[i].inflateMember(genericMember);
            }
            return result;
        }

        /// <summary>
        /// 初始化泛型形参。
        /// </summary>
        /// <param name="ps"></param>
        protected void initGenericParameters(GenericParameter[] ps) {
            var index = 0;
            foreach (var p in ps) {
                p.containerDefinitionMember = this;
                p.index = index++;
            }
        }

        /// <summary>
        /// 表示一个类型数组比较器。
        /// </summary>
        protected sealed class TypeReferenceArrayComparer : IEqualityComparer<TypeReference[]> {

            /// <summary>
            /// 获取当前比较器的默认实例。
            /// </summary>
            public static readonly TypeReferenceArrayComparer @default = new TypeReferenceArrayComparer();

            public bool Equals(TypeReference[] x, TypeReference[] y) {
                if (x == y) {
                    return true;
                }
                if (x.Length != y.Length) {
                    return false;
                }
                for (int i = 0; i < x.Length; ++i) {
                    if (x[i] != y[i]) {
                        return false;
                    }
                }
                return true;
            }

            public int GetHashCode(TypeReference[] obj) {
                int hash = 0;
                for (int i = 0; i < obj.Length; ++i)
                    hash = (hash << 5) - hash + obj[i].GetHashCode();
                return hash;
            }
        }

        #endregion

        #region 语义解析

        /// <summary>
        /// 获取当前成员的类型。
        /// </summary>
        public abstract MemberType memberType {
            get;
        }

        /// <summary>
        /// 获取当前成员的源定义。如果当前成员是外部导入的，则返回 null。
        /// </summary>
        public MemberDefinition definition;

        /// <summary>
        /// 获取当前成员的修饰符。
        /// </summary>
        public Modifiers modifiers;

        /// <summary>
        /// 判断当前成员是否是抽象的。
        /// </summary>
        public bool isAbstract {
            get {
                return (modifiers & Modifiers.@abstract) != 0;
            }
        }

        /// <summary>
        /// 判断当前成员是否是虚拟的。
        /// </summary>
        public bool isVirtual {
            get {
                return (modifiers & Modifiers.@virtual) != 0;
            }
        }

        /// <summary>
        /// 判断当前成员是否是公开的。
        /// </summary>
        public bool isPublic {
            get {
                return (modifiers & (Modifiers.@private | Modifiers.@protected)) == 0;
            }
        }

        /// <summary>
        /// 判断当前成员是否是私有的。
        /// </summary>
        public bool isPrivate {
            get {
                return (modifiers & Modifiers.@private) != 0;
            }
        }

        /// <summary>
        /// 判断当前成员是否是静态的。
        /// </summary>
        public bool isStatic {
            get {
                return (modifiers & Modifiers.@static) != 0;
            }
        }

        /// <summary>
        /// 判断当前成员是否比指定成员有相同或更高的访问权限。
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public bool isAccessibleAs(MemberReference other) {

            // 检查泛型实参是否都能访问。
            if (genericArguments != null) {
                foreach (var genericArgument in genericArguments) {
                    if (!genericArgument.isAccessibleAs(other)) {
                        return false;
                    }
                }
            }

            if (containerType != null && !containerType.isAccessibleAs(other)) {
                return false;
            }

            switch (modifiers.getAccessibility()) {
                case Modifiers.@public:
                case Modifiers.none:
                    return true;

                case Modifiers.@private:
                    var c = other;
                    do {
                        if (c.modifiers.hasFlag(Modifiers.@private)) {
                            return true;
                        }
                        if (c == container) {
                            break;
                        }
                    } while ((c = c.container) != null);
                    return false;

                default:
                    var c2 = other;
                    do {
                        if (c2.modifiers.hasFlag(Modifiers.@private | Modifiers.@protected)) {
                            if (other.container.memberType == MemberType.@namespace && c2.modifiers.getAccessibility() == Modifiers.@protected && !isNestedChildOf(other.container)) {
                                return false;
                            }
                            return true;
                        }
                        if (c2 == container) {
                            break;
                        }
                    } while ((c2 = c2.container) != null);
                    return false;

            }
        }

        /// <summary>
        /// 判断当前成员是否重写了目标成员。
        /// </summary>
        /// <param name="other">被重写的目标成员。</param>
        /// <returns>如果成员被重写返回 true。</returns>
        public virtual bool isOverriding(MemberReference other) {
            return memberType != other.memberType || hasSameGenericParameterCount(other);
        }

        #endregion

    }

    [Flags]
    public enum ResolveFlags {
        #region 暂时不能删除
        // Returns Value, Variable, PropertyAccess, EventAccess or IndexerAccess.
        VariableOrValue = 1,

        // Returns a type expression.
        Type = 1 << 1,

        // Returns a method group.
        MethodGroup = 1 << 2,

        TypeParameter = 1 << 3,

        // Mask of all the expression class flags.
        MaskExprClass = VariableOrValue | Type | MethodGroup | TypeParameter,
        #endregion


        Obsolete_Undetected = 1,	// Obsolete attribute has not been detected yet
        Obsolete = 1 << 1,			// Member has obsolete attribute

        MissingDependency_Undetected = 1 << 4,
        MissingDependency = 1 << 5,
        HasDynamicElement = 1 << 6,
        ConstraintsChecked = 1 << 7,

        IsAccessor = 1 << 9,		// Method is an accessor
        IsGeneric = 1 << 10,		// Member contains type arguments

        PendingMetaInflate = 1 << 12,
        PendingMakeMethod = 1 << 13,

        InterfacesExpanded = 1 << 16,
        IsNotCSharpCompatible = 1 << 17,
        SpecialRuntimeType = 1 << 18,
        InflatedExpressionType = 1 << 19,
        InflatedNullableType = 1 << 20,
        GenericIterateInterface = 1 << 21,
        GenericTask = 1 << 22,
        InterfacesImported = 1 << 23,
        checkingBaseType,
    }

    #endregion

    #region NamespaceReferences

    /// <summary>
    /// 表示一个命名空间引用。
    /// </summary>
    public partial class NamespaceReference : MemberReference {

        #region 待删除的

        protected MemberCache cache;

        //
        // A cache of all type members (including nested types)
        //
        public MemberCache MemberCache {
            get {
                //if (cache == null || (resolveFlags & ResolveFlags.initedAllMembers) != 0)
                //    InitializeMemberCache(false);

                return cache;
            }
            set {
                if (cache != null)
                    throw new InternalErrorException("Membercache reset");

                cache = value;
            }
        }

        public MemberCache MemberCacheTypes {
            get {
                //if (cache == null)
                //    InitializeMemberCache(true);

                return cache;
            }
        }

        public new ITypeDefinition MemberDefinition2 {
            get {
                return (ITypeDefinition)definition2;
            }
        }

        #endregion

        #region 属性

        /// <summary>
        /// 获取当前成员的源定义。如果当前成员是外部导入的，则返回 null。
        /// </summary>
        public new MemberContainerDefinition definition {
            get {
                return (MemberContainerDefinition)base.definition;
            }
            set {
                base.definition = value;
            }
        }

        /// <summary>
        /// 获取当前成员的类型。
        /// </summary>
        public override MemberType memberType {
            get {
                return MemberType.@namespace;
            }
        }

        #endregion

        #region 子成员

        /// <summary>
        /// 当前容器内的全部子成员。
        /// </summary>
        Dictionary<string, MemberReference> _members;

        /// <summary>
        /// 获取当前容器内的所有成员。
        /// </summary>
        public virtual Dictionary<string, MemberReference> members {
            get {
                if (_members == null) {
                    _members = new Dictionary<string, MemberReference>(16);
                }
                return _members;
            }
            set {
                _members = value;
            }
        }

        /// <summary>
        /// 向当前容器添加一个子成员。
        /// </summary>
        /// <param name="member">要添加的子成员。</param>
        /// <returns>返回原容器中已存在的第一个同名成员，如果原来不存在则返回 null。</returns>
        public MemberReference addMember(MemberReference member) {

            // 更新子成员的容器对象。
            member.container = this;

            // 判断重复，重复则添加到链表末尾。
            MemberReference exist;
            if (members.TryGetValue(member.name, out exist)) {
                var c = exist;
                while (c.next != null) {
                    c = c.next;
                }
                c.next = member;
                return exist;
            }

            _members[member.name] = member;
            return null;
        }

        /// <summary>
        /// 替换指定的成员为另一个成员。
        /// </summary>
        /// <param name="member"></param>
        public void removeMember(MemberReference member) {

            // 更新子成员的容器对象。
            member.container = null;

            // 判断重复，重复则添加到链表末尾。
            MemberReference exist;
            if (_members != null && _members.TryGetValue(member.name, out exist)) {
                if (exist == member) {
                    _members[member.name] = exist.next;
                } else {
                    var c = exist;
                    while (c.next != null) {
                        if (c.next == member) {
                            c.next = c.next.next;
                            break;
                        }
                        c = c.next;
                    }
                }
            }

        }

        /// <summary>
        /// 获取当前容器中具有指定名字的子成员链表。
        /// </summary>
        /// <param name="name">要获取的成员名。</param>
        /// <returns>返回链表中的第一个成员。</returns>
        public MemberReference getMember(string name) {
            MemberReference result;
            members.TryGetValue(name, out result);
            return result;
        }

        /// <summary>
        /// 获取当前容器中具有指定名字和泛型形参个数的子成员。
        /// </summary>
        /// <param name="name">要获取的成员名。</param>
        /// <param name="genericArgumentCount">要获取的泛型泛型参数个数。如果不获取泛型，则传递 0。</param>
        /// <returns>返回匹配的成员。</returns>
        public MemberReference getMember(string name, int genericArgumentCount) {
            for (var found = getMember(name); found != null; found = found.next) {
                if (found.genericParameterCount == genericArgumentCount) {
                    return found;
                }
            }

            return null;
        }

        #endregion

        #region 泛型

        /// <summary>
        /// 填充当前成员相关的泛型并返回新类型。
        /// </summary>
        /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
        /// <returns>返回填充后的新成员。</returns>
        public override MemberReference inflateMember(MemberReference genericMember) {
            // Namespace 本身不会被作为类型子成员，不会填充泛型。
            throw new Unreachable();
        }

        #endregion

        public override List<MissingTypeSpecReference> ResolveMissingDependencies(MemberReference caller) {
            throw new NotImplementedException();
        }

    }

    /// <summary>
    /// 表示一个类型（如类、结构、接口、枚举）引用。
    /// </summary>
    /// <remarks>
    /// 类型可能是泛型。
    /// TypeReference - 无泛型形参或实参
    /// GenericTypeDefinitionReference - 带形参
    /// GenericTypeReference - 带实参
    /// </remarks>
    public partial class TypeReference : NamespaceReference {

        #region 属性

        /// <summary>
        /// 获取当前成员的源定义。如果当前成员是外部导入的，则返回 null。
        /// </summary>
        public new TypeDefinition definition {
            get {
                return (TypeDefinition)base.definition;
            }
            set {
                base.definition = value;
            }
        }

        /// <summary>
        /// 获取当前类型对应的基础类型。
        /// </summary>
        public virtual PrimitiveType primitiveType {
            get {
                return PrimitiveType.none;
            }
        }

        /// <summary>
        /// 判断当前类型是否是值类型。
        /// </summary>
        public bool isValueType {
            get {
                return PredefinedTypes.System_ValueType.isAssignableTypeFrom(this);
            }
        }

        /// <summary>
        /// 判断当前类型是否是其它类或其基类。
        /// </summary>
        /// <param name="other">要判断的类型。</param>
        /// <returns></returns>
        public bool isAssignableTypeFrom(TypeReference other) {
            Debug.Assert(other != null);

            TypeReference c = other;
            do {
                if (c == this) {
                    return true;
                }
                c = c.baseClass;
            } while (c != null);
            return false;
        }

        /// <summary>
        /// 判断当前类型是否是其它类型或其基类型。
        /// </summary>
        /// <param name="other">要判断的类型。</param>
        /// <returns></returns>
        public bool isAssignableFrom(TypeReference other) {
            Debug.Assert(other != null);

            if (isAssignableTypeFrom(other)) {
                return true;
            }

            if (baseInterfaces != null) {
                foreach (var baseInterface in baseInterfaces) {
                    if (baseInterface.isAssignableFrom(other)) {
                        return true;
                    }
                }
            }

            return false;
        }

        /// <summary>
        /// 判断当前类型是否是其它类的子类。
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public bool isSubClassOf(TypeReference other) {
            for (var c = baseClass; c != null; c = c.baseClass) {
                if (c == other) {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 当前成员的类型。
        /// </summary>
        MemberType _memberType;

        /// <summary>
        /// 获取当前成员的类型。
        /// </summary>
        public override MemberType memberType {
            get {
                return _memberType;
            }
        }

        /// <summary>
        /// 初始化 <see cref="TypeReference"/> 类的新实例。
        /// </summary>
        /// <param name="memberType">成员的类型。</param>
        public TypeReference(MemberType memberType) {
            Debug.Assert(memberType == MemberType.@class ||
                memberType == MemberType.@struct ||
                memberType == MemberType.@interface || memberType == MemberType.@enum || memberType == MemberType.typeParameter || memberType == MemberType.specailType || memberType == MemberType.constraintType);
            _memberType = memberType;
        }

        #endregion

        #region 基类型

        /// <summary>
        /// 当前类型的基类。
        /// </summary>
        private TypeReference _baseClass;

        /// <summary>
        /// 获取当前类型的基类。
        /// </summary>
        public virtual TypeReference baseClass {
            get {
                return _baseClass;
            }
            set {
                _baseClass = value;
            }
        }

        /// <summary>
        /// 当前类型的基接口列表。
        /// </summary>
        private List<TypeReference> _baseInterfaces;

        /// <summary>
        /// 获取当前类型的基接口列表。
        /// </summary>
        public virtual List<TypeReference> baseInterfaces {
            get {
                return _baseInterfaces;
            }
            set {
                _baseInterfaces = value;
            }
        }

        /// <summary>
        /// 向当前类型添加一个实现的接口。
        /// </summary>
        /// <param name="interfaceType">要添加的接口类型。</param>
        /// <returns>返回原接口是否已存在。</returns>
        public bool addInterface(TypeReference interfaceType) {

            if (_baseInterfaces == null) {
                _baseInterfaces = new List<TypeReference> { interfaceType };
                return true;
            }

            if (!_baseInterfaces.Contains(interfaceType)) {
                _baseInterfaces.Add(interfaceType);
                return true;
            }

            return false;
        }

        #endregion

        #region 泛型

        /// <summary>
        /// 获取当前类型的泛型定义。如果当前类型不是泛型定义，则返回自身。
        /// </summary>
        public TypeReference genericDefinitionType {
            get {
                return (TypeReference)genericDefinition;
            }
        }

        /// <summary>
        /// 填充当前成员相关的泛型并返回新类型。
        /// </summary>
        /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
        /// <returns>返回填充后的新成员。</returns>
        public override MemberReference inflateMember(MemberReference genericMember) {

            // 填充泛型定义的内嵌类型时，会执行此函数。
            //
            // class A<T> {
            //   class B {}
            // }
            //
            return new GenericTypeReference(this, genericParameters);
        }

        /// <summary>
        /// 应用指定的泛型实参以替换当前类型。
        /// </summary>
        /// <param name="genericMember">引发本次操作的泛型。</param>
        /// <returns>返回替换后的新类型。</returns>
        public virtual TypeReference inflate(MemberReference genericMember) {
            // 普通类型无需替换。
            return this;
        }

        ///// <summary>
        ///// 基于当前泛型定义创建新的类型。
        ///// </summary>
        ///// <param name="genericArguments">要使用的泛型实参。</param>
        ///// <param name="srcGenericArguments">泛型参数源。</param>
        ///// <returns>返回新的泛型成员。</returns>
        //public virtual GenericTypeReference makeGenericType(params TypeReference[] genericArguments) {
        //    // 为确保泛型实体唯一，必须通过父类扩充泛型然后再获取。
        //    Debug.Assert(container != null);
        //    Debug.Assert(container.isGeneric);
        //    Debug.Assert(genericArguments.Length == 0);
        //    return (GenericTypeReference)container.getMember(name, 0);
        //}

        #endregion

        #region 成员检查

        private bool _typeChecked;

        /// <summary>
        /// 验证当前类型的完整性。
        /// </summary>
        /// <param name="srcNode">解析为当前类型的原始节点。</param>
        public virtual void checkType(Expression srcNode) {

            // 只检查一次。
            if (_typeChecked) {
                return;
            }

            _typeChecked = true;

            Compiler.echo("检查：  " + signature);

            // 验证泛型约束是否符合要求。




            // 验证成员是否依赖了外部导入类型。

            // 验证成员是否被否定。
        }


        #endregion

        #region 类型成员展开

        /// <summary>
        /// 存储属于当前类型展开继承信息后的全部成员，这些成员来自于类型自身、基类、接口和扩展。
        /// </summary>
        Dictionary<string, MemberReferenceGroup> _resolvedMemberCache;

        /// <summary>
        /// 获取存储属于当前类型展开继承信息后的全部成员，这些成员来自于类型自身、基类、接口和扩展。
        /// </summary>
        private Dictionary<string, MemberReferenceGroup> resolvedMemberCache {
            get {
                if (_resolvedMemberCache == null) {
                    _resolvedMemberCache = new Dictionary<string, MemberReferenceGroup>();
                }
                return _resolvedMemberCache;
            }
        }

        /// <summary>
        /// 获取当前类型的直接扩展。
        /// </summary>
        public MemberReferenceGroup extensions {
            get {
                MemberReferenceGroup result;
                resolvedMemberCache.TryGetValue("@extensions", out result);
                return result;
            }
        }

        /// <summary>
        /// 添加一个当前类型的扩展。
        /// </summary>
        /// <param name="extension"></param>
        public void addExtension(ExtensionReference extension) {
            MemberReferenceGroup result;
            if (!resolvedMemberCache.TryGetValue("@extensions", out result)) {
                _resolvedMemberCache["@extensions"] = result = new MemberReferenceGroup();
            }
            result.Add(extension);
        }

        /// <summary>
        /// 获取当前类型展开继承信息后所有指定名称的成员。
        /// </summary>
        /// <param name="name">要获取的成员名。</param>
        /// <returns>返回成员组。</returns>
        public MemberReferenceGroup getAllMembers(string name) {

            // 此函数将收集当前类型的全部实际成员。
            // 一个类的实际成员主要来自于：
            //    1. 当前类。
            //    2. 基类。
            //    3. 接口默认实现。

            // 此函数的返回值是一个集合，
            // 对于不可重载的成员（如字段、属性），集合有且仅有一个元素。
            // 对于可重载的成员（如方法、索引器、构造函数），集合包含全部可用重载。

            // 由于成员经常重复调用，
            // 本函数会负责对处理的结果进行缓存。
            MemberReferenceGroup result;
            if (resolvedMemberCache.TryGetValue(name, out result)) {
                return result;
            }

            // 由于大部分成员都继承基类，不需要为每个成员创建集合缓存，
            // 为节约内存，如果当前类的成员全部继承自基类，则使用相同的
            // 对象保存。
            int baseCount = -1;
            result = MemberReferenceGroup.alloc();

            // 收集当前类的成员。
            for (var member = getMember(name); member != null; member = member.next) {
                result.Add(member);
            }

            MemberReferenceGroup baseMembers;

            // 基类的全部实际成员都是当前类的实际成员。
            // 如果基类成员是私有的，则从基类的直接
            if (baseClass != null && (baseMembers = baseClass.getAllMembers(name)) != null) {
                int thisCount = result.Count;
                baseCount = baseMembers.Count;
                foreach (var baseMember in baseMembers) {
                    if (!baseMember.isPrivate && ResolveHelper.isNewOverload(result, thisCount, baseMember)) {
                        result.Add(baseMember);
                    } else {
                        baseCount = -1;
                    }
                }
            }

            // 接口所有默认实现都是当前类的实际成员。
            if (baseInterfaces != null) {
                foreach (var baseInterface in baseInterfaces) {
                    if ((baseMembers = baseInterface.getAllMembers(name)) != null) {
                        int thisCount = result.Count;
                        foreach (var baseMember in baseMembers) {
                            // 如果当前类型是接口，则接口的继承成员直接复制；否则需复制所有默认实现。
                            if (_memberType == MemberType.@interface || (baseMember.isVirtual && ResolveHelper.isNewOverload(result, thisCount, baseMember))) {
                                result.Add(baseMember);
                            }
                        }
                    }
                }
            }

            if (result.Count == 0) {
                MemberReferenceGroup.free(result);
                result = null;
            } else if (result.Count == baseCount) {
                MemberReferenceGroup.free(result);
                result = baseClass == null ? null : baseClass.getAllMembers(name);
            }

            return _resolvedMemberCache[name] = result;
        }

        /// <summary>
        /// 获取当前类型展开继承信息后所有指定名称的成员。
        /// </summary>
        /// <param name="name">要获取的成员名。</param>
        /// <param name="genericArgumentCount">要获取的泛型泛型参数个数。如果不获取泛型，则传递 0。</param>
        /// <returns>返回成员组。</returns>
        public MemberReferenceGroup getAllMembers(string name, int genericArgumentCount) {
            var members = getAllMembers(name);
            if (members != null) {
                members = members.findAll(member => member.matchGenericArgumentCount(genericArgumentCount));
            }

            return members;
        }

        /// <summary>
        /// 获取当前类型的实际构造函数。
        /// </summary>
        /// <returns>返回成员组。</returns>
        public MemberReferenceGroup getAllConstrutors() {

            MemberReferenceGroup result;

            // 先从缓存对象读取。
            if (resolvedMemberCache.TryGetValue("@ctor", out result)) {
                return result;
            }

            result = MemberReferenceGroup.alloc();

            // 读取用户定义的构造函数。
            var member = getMember("@ctor");
            if (member != null) {
                do {
                    result.Add(member);
                } while ((member = member.next) != null);

            } else {

                // 生成默认的构造函数。
                var constructor = new MethodReference(MemberType.constructor);
                constructor.name = "@ctor";
                constructor.returnType = PredefinedTypes.@void;

                // 找到当前类的全部 final 字段。
                var finalFields = getAllFinalFields();
                if (finalFields == null) {
                    constructor.parameters = new MethodReference.Parameter[0];
                } else {
                    MethodReference.Parameter[] parameters = new MethodReference.Parameter[finalFields.Count];
                    for (int i = 0; i < parameters.Length; i++) {
                        var f = (FieldReference)finalFields[i];
                        var p = new MethodReference.Parameter();
                        p.name = f.name;
                        p.type = f.returnType;
                        //   p.defaultValue = f.initialValue ?? NullConstant.@default;
                        parameters[i] = p;
                    }
                    constructor.parameters = parameters;
                }

                result.Add(constructor);
            }

            return _resolvedMemberCache[name] = result;
        }

        /// <summary>
        /// 获取当前类型展开继承信息的最终字段。
        /// </summary>
        /// <returns></returns>
        public MemberReferenceGroup getAllFinalFields() {

            MemberReferenceGroup result;
            if (resolvedMemberCache.TryGetValue("@allFinalMembers", out result)) {
                return result;
            }

            result = MemberReferenceGroup.alloc();

            MemberReferenceGroup baseMembers;

            // 从基类收集。
            if (baseClass != null && (baseMembers = baseClass.getAllFinalFields()) != null) {
                foreach (var baseMember in baseMembers) {
                    if (!baseMember.modifiers.hasFlag(Modifiers.@private)) {
                        result.Add(baseMember);
                    }
                }
            }

            // 从本类收集。
            foreach (var member in members) {
                if (member.Value.memberType == MemberType.field && member.Value.modifiers.hasFlag(Modifiers.final)) {
                    result.Add(member.Value);
                }
            }

            if (result.Count == 0) {
                MemberReferenceGroup.free(result);
                result = null;
            }

            return _resolvedMemberCache["@allFinalMembers"] = result;
        }

        /// <summary>
        /// 获取和当前类型相关的类型。如当前类、基类和基接口。
        /// </summary>
        /// <returns></returns>
        public MemberReferenceGroup getAllRequiredTypes() {

            MemberReferenceGroup result;
            if (resolvedMemberCache.TryGetValue("@allRequiredTypes", out result)) {
                return result;
            }

            result = MemberReferenceGroup.alloc();
            result.Add(this);

            // 如果当前类型是泛型，则泛型定义是相关的。
            var underlyType = genericDefinitionType;
            if (underlyType != this) {
                result.Add(underlyType);
            }
            if (baseClass != null) {
                foreach (var member in baseClass.getAllRequiredTypes()) {
                    if (!result.Contains(member)) {
                        result.Add(member);
                    }
                }
            }
            if (baseInterfaces != null) {
                foreach (var implementedType in baseInterfaces) {
                    foreach (var member in implementedType.getAllRequiredTypes()) {
                        if (!result.Contains(member)) {
                            result.Add(member);
                        }
                    }
                }
            }

            return _resolvedMemberCache["@allRequiredTypes"] = result;
        }

        /// <summary>
        /// 获取适用于当前类型的全部扩展。
        /// </summary>
        /// <returns></returns>
        public MemberReferenceGroup getAllExtensions() {

            MemberReferenceGroup result;
            if (resolvedMemberCache.TryGetValue("@allExtensions", out result)) {
                return result;
            }

            foreach (TypeReference referencedType in getAllRequiredTypes()) {
                var extensions = referencedType.extensions;
                if (extensions != null) {
                    if (result == null) {
                        result = MemberReferenceGroup.alloc();
                    }
                    result.AddRange(extensions);
                }
            }

            return _resolvedMemberCache["@allExtensions"] = result;
        }

        /// <summary>
        /// 获取当前类型展开继承信息的所有未实现的抽象成员列表。
        /// </summary>
        /// <returns>所有抽象成员列表的只读版本。如果不存在则返回 null。</returns>
        public MemberReferenceGroup getAllAbstractMembers() {

            // 不是抽象类，没有抽象成员。
            if (!modifiers.hasFlag(Modifiers.@abstract)) {
                return null;
            }

            MemberReferenceGroup result;
            if (resolvedMemberCache.TryGetValue("@allAbstractMembers", out result)) {
                return result;
            }

            result = MemberReferenceGroup.alloc();

            // 收集当前类的抽象成员。
            foreach (var vd in members) {
                for (var member = vd.Value; member != null; member = member.next) {
                    if (member.modifiers.hasFlag(Modifiers.@abstract)) {
                        result.Add(member);
                    }
                }
            }

            // 收集当前类未实现的基类抽象成员。
            if (baseClass != null) {
                var baseMembers = baseClass.getAllAbstractMembers();
                if (baseMembers != null) {
                    foreach (var baseMember in baseMembers) {
                        if (getOverrideingMemberFromThis(baseMember.name, baseMember) == null) {
                            result.Add(baseMember);
                        }
                    }
                }
            }

            if (result.Count == 0) {
                MemberReferenceGroup.free(result);
                result = null;
            }

            return _resolvedMemberCache["@allAbstractMembers"] = result;
        }

        /// <summary>
        /// 获取当前接口展开继承信息的所有成员。
        /// </summary>
        /// <returns></returns>
        public MemberReferenceGroup getAllIneterfaceMembers() {

            Debug.Assert(memberType == MemberType.@interface, "只有接口才能获取接口成员");

            MemberReferenceGroup result;
            if (resolvedMemberCache.TryGetValue("@allIneterfaceMembers", out result)) {
                return result;
            }

            result = MemberReferenceGroup.alloc();

            // 从本类收集。
            foreach (var vd in members) {
                for (var member = vd.Value; member != null; member = member.next) {
                    result.Add(member);
                }
            }

            // 从接口收集。
            if (baseInterfaces != null) {
                foreach (var bi in baseInterfaces) {
                    var bim = bi.getAllIneterfaceMembers();
                    if (bim != null) {
                        foreach (var member in bim) {
                            result.Add(member);
                        }
                    }
                }
            }

            if (result.Count == 0) {
                MemberReferenceGroup.free(result);
                result = null;
            }

            return _resolvedMemberCache["@allIneterfaceMembers"] = result;
        }

        /// <summary>
        /// 获取当前类和基类下对指定成员重写的成员。
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public MemberReference getOverrideingMember(MemberReference other) {
            var members = getAllMembers(other.name);
            if (members != null) {
                foreach (var member in members) {
                    if (member.isOverriding(other)) {
                        return member;
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// 获取当前类和基类下对指定成员重写的成员。
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        public MemberReference getOverrideingMemberFromThis(string name, MemberReference other) {
            for (var member = getMember(name); member != null; member = member.next) {
                if (member.isOverriding(other)) {
                    return member;
                }
            }
            return null;
        }

        public MemberReference addExplicitMember(TypeReference explicitType, MemberReference member) {
            member.name = ResolveHelper.toExplicitName(explicitType, member.name);
            return addMember(member);
        }

        /// <summary>
        /// 在当前类查找和指定成员相同的显式接口成员。
        /// </summary>
        /// <param name="other">要获取的接口成员。</param>
        /// <returns></returns>
        public MemberReference getExplicitMember(MemberReference other) {
            var name = ResolveHelper.toExplicitName(other.containerType, other.name);
            var t = this;
            do {
                var found = t.getOverrideingMemberFromThis(name, other);
                if (found != null) {
                    return found;
                }
            } while ((t = t.containerType) != null);
            return null;
        }

        #endregion

    }

    /// <summary>
    /// 表示一个泛型类型定义引用。
    /// </summary>
    public partial class GenericTypeDefinitionReference : TypeReference {

        /// <summary>
        /// 当前成员引用的泛型参数。可能是泛型形参或实参。
        /// </summary>
        protected TypeReference[] typeArguments;

        /// <summary>
        /// 获取当前成员的泛型形参。
        /// </summary>
        /// <remarks>
        /// 如果当前类型是泛型实体或泛型定义的非泛型内嵌类，则返回 null。
        /// </remarks>
        public override GenericParameter[] genericParameters {
            get {
                return (GenericParameter[])typeArguments;
            }
        }

        /// <summary>
        /// 将当前成员的签名写入字符串缓存。
        /// </summary>
        /// <param name="buffer">用于写入的缓冲区对象。</param>
        public override void writeSignature(StringBuilder buffer) {
            base.writeSignature(buffer);
            TypeReference[] args = genericParameters;
            if (args == null) {
                args = genericArguments;
            }
            if (args != null) {
                buffer.Append("<");
                for (int i = 0; i < typeArguments.Length; i++) {
                    typeArguments[i].writeSignature(buffer);
                    buffer.Append(", ");
                }
                buffer.Length--;
                buffer[buffer.Length - 1] = '>';
            }
        }

        /// <summary>
        /// 创建一个新的泛型定义。
        /// </summary>
        /// <param name="memberType">成员的类型。</param>
        /// <param name="genericArguments">当前成员的泛型实参。</param>
        protected GenericTypeDefinitionReference(MemberType memberType, TypeReference[] genericArguments)
            : base(memberType) {
            typeArguments = genericArguments;
        }

        /// <summary>
        /// 创建一个新的泛型定义。
        /// </summary>
        /// <param name="memberType">成员的类型。</param>
        /// <param name="genericParameters">当前成员的泛型实参。</param>
        public GenericTypeDefinitionReference(MemberType memberType, GenericParameter[] genericParameters)
            : base(memberType) {
            typeArguments = genericParameters;
        }

        /// <summary>
        /// 应用指定的泛型实参以替换当前类型。
        /// </summary>
        /// <param name="genericMember">引发本次操作的泛型。</param>
        /// <returns>返回替换的类型。</returns>
        public override TypeReference inflate(MemberReference genericMember) {
            // 泛型定义不会进入。
            throw new Unreachable();
        }

        /// <summary>
        /// 存储生成的泛型。
        /// </summary>
        private Dictionary<TypeReference[], TypeReference> _makedGenericTypes;

        /// <summary>
        /// 基于当前泛型定义创建新的类型。
        /// </summary>
        /// <param name="genericArguments">要使用的泛型实参。</param>
        /// <param name="srcGenericArguments">泛型参数源。</param>
        /// <returns>返回新的泛型成员。</returns>
        public TypeReference makeGenericType(params TypeReference[] genericArguments) {

            Debug.Assert(this.genericArguments == null, "已经是泛型不会重复生成");

            if (_makedGenericTypes == null) {
                _makedGenericTypes = new Dictionary<TypeReference[], TypeReference>(TypeReferenceArrayComparer.@default);
            }

            TypeReference result;
            if (!_makedGenericTypes.TryGetValue(genericArguments, out result)) {
                _makedGenericTypes[genericArguments] = result = createGenericType(genericArguments);
            }

            return result;
        }

        /// <summary>
        /// 当被子类重写时，负责创建新的泛型。
        /// </summary>
        /// <param name="genericArguments">当前泛型的实参。</param>
        /// <returns>新生成的泛型。</returns>
        protected virtual TypeReference createGenericType(TypeReference[] genericArguments) {
            return new GenericTypeReference(this, genericArguments);
        }

    }

    /// <summary>
    /// 表示一个泛型类型引用。
    /// </summary>
    /// <remarks>
    /// 此类型包括：泛型实体、泛型定义的内嵌泛型定义。
    /// </remarks>
    public partial class GenericTypeReference : GenericTypeDefinitionReference {

        #region 属性

        /// <summary>
        /// 表示解析的标记位。
        /// </summary>
        private enum Flags {

            /// <summary>
            /// 标记当前泛型是泛型定义。
            /// </summary>
            isDefinition = 1 << 0,

            /// <summary>
            /// 标记当前类型的泛型形参已初始化。
            /// </summary>
            genericParametersInited = 1 << 2,

            /// <summary>
            /// 标记当前类型的基类已初始化。
            /// </summary>
            baseClassInited = 1 << 3,

            /// <summary>
            /// 标记当前类型的基接口已初始化。
            /// </summary>
            baseInterfacesInited = 1 << 4,

            /// <summary>
            /// 标记当前类型的子类型已初始化。
            /// </summary>
            childTypesInited = 1 << 5,

            /// <summary>
            /// 标记当前类型的子成员已初始化。
            /// </summary>
            childMembersInited = 1 << 6,

        }

        /// <summary>
        /// 当前类型解析标记。
        /// </summary>
        private Flags _flags;

        /// <summary>
        /// 当前类型的泛型定义。
        /// </summary>
        private TypeReference _genericDefinition;

        /// <summary>
        /// 获取当前类型的泛型定义。如果当前类型不是泛型定义，则返回自身。
        /// </summary>
        public override MemberReference genericDefinition {
            get {
                return _genericDefinition;
            }
        }

        /// <summary>
        /// 获取当前成员的泛型形参。
        /// </summary>
        /// <remarks>
        /// 如果当前类型是泛型实体或泛型定义的非泛型内嵌类，则返回 null。
        /// </remarks>
        public override GenericParameter[] genericParameters {
            get {

                // 只有泛型定义才有泛型形参。
                if ((_flags & Flags.isDefinition) == 0) {
                    return null;
                }

                var ps = (GenericParameter[])typeArguments;

                // 初始化泛型形参。
                if ((_flags & Flags.genericParametersInited) != 0) {
                    Debug.Assert(_genericDefinition.definition == null || (_genericDefinition.definition.flags & TypeDefinition.Flags.baseTypesResolved) != 0, "解析基类型时不允许解析泛型约束");
                    _flags |= Flags.genericParametersInited;
                    if (ps != null) {
                        typeArguments = inflateGenericParameters(ps, this);
                        initGenericParameters(ps);
                    }
                }

                return ps;
            }
        }

        /// <summary>
        /// 获取当前成员的泛型实参。
        /// </summary>
        /// <remarks>
        /// 如果当前类型是泛型定义或泛型定义的非泛型内嵌类，则返回 null。
        /// </remarks>
        public override TypeReference[] genericArguments {
            get {
                // 泛型定义没有泛型实参。
                if ((_flags & Flags.isDefinition) != 0) {
                    return null;
                }
                return typeArguments;
            }
        }

        /// <summary>
        /// 获取当前成员的指定内置注解。
        /// </summary>
        /// <param name="annotationType">要获取的内置注解类型。</param>
        /// <returns>包含此内置注解的数据。</returns>
        protected override MemberAnnotation loadAnnotation(TypeReference annotationType) {
            // 泛型始终不含注解。
            return _genericDefinition.getAnnotation(annotationType);
        }

        /// <summary>
        /// 创建一个新的泛型实例。
        /// </summary>
        /// <param name="genericDefinitionType">产生当前泛型的泛型定义。</param>
        /// <param name="genericArguments">当前成员的泛型实参。</param>
        public GenericTypeReference(TypeReference genericDefinitionType, TypeReference[] genericArguments)
            : base(genericDefinitionType.memberType, genericArguments.Length == 0 ? null : genericArguments) {
            setDefinition(genericDefinitionType);
        }

        /// <summary>
        /// 创建一个新的内嵌泛型定义。
        /// </summary>
        /// <param name="genericDefinitionType">产生当前泛型的泛型定义。</param>
        /// <param name="genericParameters">当前成员的泛型实参。</param>
        public GenericTypeReference(TypeReference genericDefinitionType, GenericParameter[] genericParameters)
            : base(genericDefinitionType.memberType, genericParameters) {
            _flags = Flags.isDefinition;
            setDefinition(genericDefinitionType);
            // 如果原始类型不是泛型，genericParameters 为 null。
        }

        private void setDefinition(TypeReference genericDefinitionType) {
            _genericDefinition = genericDefinitionType;
            container = genericDefinitionType.container;
            definition = genericDefinitionType.definition;
            modifiers = genericDefinitionType.modifiers;
            name = genericDefinitionType.name;
        }

        #endregion

        #region 基类型

        /// <summary>
        /// 获取当前类型的基类。
        /// </summary>
        public override TypeReference baseClass {
            get {
                // 创建泛型类型后，泛型定义可能仍未解析。
                // 
                // class A<T> : B<A<int>.C> {   class C{} }
                // 
                // 解析 A<T> 的基类 B<...> 时，已经生成了 A<int>，
                // 而此时 A<int> 的基类是无法获取的。
                // 
                // interface A<T> : B<A<int>>, IC { }
                // interface B<T>{ }
                // 
                // 解析 A<T> 的基接口 B<...> 时，已经生成了 A<int>，
                // 而此时 A<int> 的基接口是无法获取的。
                // 
                // 因此泛型的基类、基接口、子成员必须根据泛型定义动态获取。
                // 如果泛型定义未解析完成，则标记当前泛型未完成。

                // 获取基类时，泛型定义仍未解析，直接返回不填充的对象，
                // 以在设置基类时判定循环继承。
                // 
                // class A<T> : B<A<int>.C> { }
                // class B<T>{  class C{}  }
                // 

                // 如果当前成员是泛型成员，则通过泛型定义初始化基类。
                if ((_flags & Flags.baseClassInited) == 0) {
                    _flags |= Flags.baseClassInited;
                    if (_genericDefinition.baseClass != null && (_genericDefinition.definition == null || (_genericDefinition.definition.flags & TypeDefinition.Flags.baseTypesResolved) != 0)) {
                        base.baseClass = _genericDefinition.baseClass.inflate(this);
                    }
                }

                return base.baseClass;
            }
        }

        /// <summary>
        /// 获取当前类型的基接口列表。
        /// </summary>
        public override List<TypeReference> baseInterfaces {
            get {

                // 获取基类时，泛型定义仍未解析，直接返回不填充的对象，
                // 以在设置基类时判定循环继承。
                // 
                // interface A<T> : B<A<int>>, IC { }
                // interface B<T>{    }
                // 

                if ((_flags & Flags.baseInterfacesInited) == 0) {
                    Debug.Assert(_genericDefinition.definition == null || (_genericDefinition.definition.flags & TypeDefinition.Flags.baseTypesResolved) != 0, "解析基类型时不允许解析基接口");
                    _flags |= Flags.baseInterfacesInited;
                    var bi = _genericDefinition.baseInterfaces;
                    if (bi != null) {
                        base.baseInterfaces = new List<TypeReference>(bi.Count);
                        for (int i = 0; i < bi.Count; i++) {
                            base.baseInterfaces[i] = bi[i].inflate(this);
                        }
                    }
                }

                return base.baseInterfaces;
            }
        }

        #endregion

        #region 子成员

        /// <summary>
        /// 获取当前容器内的所有成员。
        /// </summary>
        public override Dictionary<string, MemberReference> members {
            get {
                if ((_flags & Flags.childMembersInited) == 0) {

                    // 如果子类型都未解析，则解析子类型。
                    if ((_flags & Flags.childTypesInited) == 0) {
                        _flags |= Flags.childTypesInited;
                        initMembers(false);
                    }

                    // 如果泛型定义成员类型未解析，则获取定义成员。
                    if (_genericDefinition.definition == null || (_genericDefinition.definition.flags & TypeDefinition.Flags.memberResolved) != 0) {
                        _flags |= Flags.childMembersInited;
                        initMembers(true);
                    }
                }

                return base.members;
            }
        }

        /// <summary>
        /// 初始化所有成员列表。
        /// </summary>
        /// <param name="allMembers">如果为 true，则初始化所有成员；否则只初始化类型。</param>
        private void initMembers(bool allMembers) {

            // 将泛型定义中所有项导入到当前定义。
            foreach (var memberList in _genericDefinition.members) {
                var member = memberList.Value;

                // allMembers == true: member 不能是类型。
                // allMembers == false: member 是类型。
                if (allMembers == member is TypeReference) {
                    // 首次初始化时只初始化类型，非类型使用非扩展的成员。
                    if (!allMembers) {
                        members[memberList.Key] = member;
                    }
                    continue;
                }

                for (MemberReference current = null; member != null; member = member.next) {
                    var inflatedMember = member.inflateMember(this);
                    inflatedMember.container = this;
                    if (current == null) {
                        current = members[memberList.Key] = inflatedMember;
                    } else {
                        current = current.next = inflatedMember;
                    }
                }
            }

        }

        #endregion

        #region 泛型

        /// <summary>
        /// 应用指定的泛型实参以替换当前类型。
        /// </summary>
        /// <param name="genericMember">引发本次操作的泛型。</param>
        /// <returns>返回替换的类型。</returns>
        public sealed override TypeReference inflate(MemberReference genericMember) {

            Debug.Assert(genericParameters == null, "泛型定义不会替换");

            // 如果当前类型是泛型实体的内嵌类，可能调用此函数。
            // class A<T>{
            //    class B<U> : A<T>{
            //       class D{ }
            //    }
            //    B<int>.D a;
            // }
            //
            // B<int>.D 本身是一个 GenericTypeReference，
            // 生成 A<int> 时会执行此步骤。
            if (genericArguments == null) {
                return this;
            }

            //
            // class A<T>{
            //     B<T, int> b;
            //     class C{}
            //     A<bool>.C c;
            // }
            // 生成 A<int> 时，会出现 B<T, int>.inflate([int])
            // 生成 A<int> 时，会出现 A<bool>.C.inflate([int])
            //
            // 相当于用原始泛型重新替换参数。

            // 标记泛型实参是否有所改变，如果未改变则使用当前类型。
            var newArguments = new TypeReference[typeArguments.Length];
            for (int i = 0; i < typeArguments.Length; i++) {
                newArguments[i] = typeArguments[i].inflate(genericMember);
            }

            // 让泛型定义重新生成一个指定参数的泛型。
            Debug.Assert(_genericDefinition is GenericTypeDefinitionReference, "泛型实体的原始类型一定是泛型定义");
            return ((GenericTypeDefinitionReference)_genericDefinition).makeGenericType(newArguments);

        }

        #endregion

        #region 类型检查

        private void checkConstraint() {

        }

        ///// <summary>
        ///// 应用当前泛型实参，替换相关的泛型形参。
        ///// </summary>
        ///// <param name="srcGenericArguments">提供的泛型参数源。如果当前泛型由系统自动生成的，则为 null。</param>
        //public void inflate(List<Expression> srcGenericArguments) {

        //    if (srcGenericArguments != null) {
        //        ResolveHelper.checkConstraints(genericDefinitionType, _genericArguments, srcGenericArguments);
        //    }

        //    if (genericDefinitionType.baseType != null) {
        //        baseType = genericDefinitionType.baseType.inflateType(this);
        //    }

        //    if (genericDefinitionType.implementedTypes != null) {
        //        implementedTypes = new List<TypeReference>(genericDefinitionType.implementedTypes.Count);
        //        foreach (var implementedType in genericDefinitionType.implementedTypes) {
        //            implementedTypes.Add(implementedType.inflateType(this));
        //        }

        //        if (srcGenericArguments != null) {

        //            // 如果类型继承了多个由泛型参数区分的类型，则不允许实现接口后类型相同。
        //            // class A<T, K>: I<T>, I<K>
        //            // A<int, int> 导致 T<T> 和 T<K> 不可区分。

        //            for (int i = 0; i < implementedTypes.Count; i++) {
        //                for (int j = 0; j < i; j++) {
        //                    if (implementedTypes[i] == implementedTypes[j]) {
        //                        Compiler.error(ErrorCode.none, "无法使用指定的泛型参数作为实参，因为它导致生成的新类型继承了相同的接口", srcGenericArguments[0].startLocation, srcGenericArguments[srcGenericArguments.Count - 1].endLocation);
        //                        break;
        //                    }
        //                }
        //            }

        //        }

        //    }

        //    base.inflateMembers(this);

        //}

        #endregion

    }

    /// <summary>
    /// 表示一个扩展引用。
    /// </summary>
    public partial class ExtensionReference : NamespaceReference {

        /// <summary>
        /// 获取当前成员的类型。
        /// </summary>
        public override MemberType memberType {
            get {
                return MemberType.extension;
            }
        }

        /// <summary>
        /// 获取当前扩展的目标类型。
        /// </summary>
        public TypeReference targetType;

        ///// <summary>
        ///// 获取当前扩展的接口。
        ///// </summary>
        //public List<TypeReference> baseInterfaces;

        /// <summary>
        /// 将当前成员的签名写入字符串缓存。
        /// </summary>
        /// <param name="buffer">用于写入的缓冲区对象。</param>
        public override void writeSignature(StringBuilder buffer) {
            buffer.Append("@Extended:");
            targetType.writeSignature(buffer);
        }

        public override List<MissingTypeSpecReference> ResolveMissingDependencies(MemberReference caller) {
            throw new NotImplementedException();
        }
    }

    /// <summary>
    /// 表示一个模块引用。
    /// </summary>
    public partial class ModuleReference : NamespaceReference {

        /// <summary>
        /// 当前模块的导入路径。
        /// </summary>
        public string sourcePath;

        public override List<MissingTypeSpecReference> ResolveMissingDependencies(MemberReference caller) {
            throw new NotImplementedException();
        }

    }

    #endregion

    #region TypeMemberReferences

    /// <summary>
    /// 表示一个类型成员。
    /// </summary>
    public abstract partial class TypeMemberReference : MemberReference {

        #region 返回值

        /// <summary>
        /// 获取当前引用的返回值类型。
        /// </summary>
        public TypeReference returnType;

        #endregion

        #region 参数

        /// <summary>
        /// 表示一个函数参数。
        /// </summary>
        public partial class Parameter {

            /// <summary>
            /// 获取当前参数的类型。
            /// </summary>
            public VariableType variableType;

            /// <summary>
            /// 获取当前参数的值类型。
            /// </summary>
            public TypeReference type;

            /// <summary>
            /// 获取当前参数的名字。
            /// </summary>
            public string name;

            /// <summary>
            /// 获取当前参数的默认值。
            /// </summary>
            public Expression defaultValue;

            /// <summary>
            /// 判断当前参数是否可以有返回值。
            /// </summary>
            public bool isOutOrRef {
                get {
                    return variableType == VariableType.refParameter || variableType == VariableType.outParameter;
                }
            }

            /// <summary>
            /// 判断当前参数是否是变长参数。
            /// </summary>
            public bool isParams {
                get {
                    return variableType == VariableType.paramsParameter || variableType == VariableType.argListParameter;
                }
            }

            /// <summary>
            /// 判断当前参数是否是可选参数。
            /// </summary>
            public bool isOptional {
                get {
                    return defaultValue != null || variableType == VariableType.paramsParameter || variableType == VariableType.argListParameter;
                }
            }

            /// <summary>
            /// 返回表示当前对象的字符串。
            /// </summary>
            /// <returns>表示当前对象的字符串。</returns>
            public override string ToString() {
                return name;
            }

            /// <summary>
            /// 替换当前成员依赖的所有泛型形参并返回替换后的新成员。
            /// </summary>
            /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
            /// <returns>返回替换后的新成员。</returns>
            public Parameter inflateMember(MemberReference genericMember) {
                var result = (Parameter)MemberwiseClone();
                result.type = type.inflate(genericMember);
                return result;
            }

        }

        /// <summary>
        /// 获取当前成员的参数。如果当前成员不含参数则返回 null。
        /// </summary>
        public Parameter[] parameters {
            get {
                var method = this as MethodReference;
                if (method != null) {
                    return method.parameters;
                }
                var indexer = this as IndexerReference;
                if (indexer != null) {
                    return indexer.parameters;
                }
                return null;
            }
        }

        /// <summary>
        /// 获取当前成员指定名字的参数索引。如果当前成员不含参数则返回 null。
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public int getParameterIndex(string name) {
            var ps = parameters;
            if (ps != null) {
                for (int i = 0; i < ps.Length; ++i) {
                    if (ps[i].name == name)
                        return i;
                }
            }
            return -1;
        }

        /// <summary>
        /// 将参数写入字符串缓存。
        /// </summary>
        /// <param name="parameters"></param>
        /// <param name="buffer"></param>
        protected static void writeParameters(Parameter[] parameters, StringBuilder buffer) {
            if (parameters == null) {
                return;
            }
            for (int i = 0; i < parameters.Length; i++) {
                if (i > 0) {
                    buffer.Append(", ");
                }
                var parameter = parameters[i];
                switch (parameter.variableType) {
                    case VariableType.inParameter:
                        break;
                    case VariableType.refParameter:
                        buffer.Append("ref ");
                        break;
                    case VariableType.outParameter:
                        buffer.Append("out ");
                        break;
                    case VariableType.paramsParameter:
                        buffer.Append("params ");
                        break;
                    case VariableType.argListParameter:
                        buffer.Append("...");
                        continue;
                }
                parameter.type.writeSignature(buffer);
                buffer.Append(' ');
                buffer.Append(parameter.name);
            }
        }

        /// <summary>
        /// 判断两个方法是否拥有相同的参数。
        /// </summary>
        /// <param name="other"></param>
        /// <returns></returns>
        protected static bool hasSameParameters(Parameter[] parametersA, Parameter[] parametersB) {
            if (parametersA.Length != parametersB.Length) {
                return false;
            }

            for (int i = 0; i < parametersA.Length; i++) {
                if (parametersA[i].variableType != parametersB[i].variableType || !ResolveHelper.isOverriding(parametersA[i].type, parametersB[i].type)) {
                    return false;
                }
            }

            return true;
        }

        /// <summary>
        /// 替换所有参数依赖的所有泛型形参并返回替换后的新成员。
        /// </summary>
        /// <param name="genericParameters">要替换的参数。</param>
        /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
        /// <returns>返回替换后的新成员。</returns>
        protected static Parameter[] infalteParameters(Parameter[] parameters, MemberReference genericMember) {
            var result = new Parameter[parameters.Length];
            for (int i = 0; i < parameters.Length; i++) {
                result[i] = parameters[i].inflateMember(genericMember);
            }
            return result;
        }

        #endregion
    }

    /// <summary>
    /// 表示一个字段引用。
    /// </summary>
    public partial class FieldReference : TypeMemberReference, IInterfaceMemberSpec {

        #region 暂时不能删除

        public TypeReference MemberType2 {
            get {
                return returnType;
            }
        }

        public FieldReference Mutate(TypeParameterMutator mutator) {
            var decl = containerType;
            if (containerType.IsGenericOrParentIsGeneric)
                decl = mutator.Mutate(decl);

            if (decl == containerType)
                return this;

            var fs = (FieldReference)MemberwiseClone();
            fs.containerType = decl;
            fs.resolveFlags |= ResolveFlags.PendingMetaInflate;

            // Gets back FieldInfo in case of metaInfo was inflated
            fs.metaInfo = MemberCache.GetMember(TypeParameterMutator.GetMemberDeclaringType(containerType), this).metaInfo;
            return fs;
        }

        public override List<MissingTypeSpecReference> ResolveMissingDependencies(MemberReference caller) {
            return returnType.ResolveMissingDependencies(this);
        }

        #endregion

        /// <summary>
        /// 获取当前成员的类型。
        /// </summary>
        public override MemberType memberType {
            get {
                return MemberType.field;
            }
        }

        /// <summary>
        /// 获取当前字段的初始化值。
        /// </summary>
        public Expression initialValue;

        /// <summary>
        /// 获取当前字段对应的源变量。
        /// </summary>
        public Variable variable {
            get {
                var field = genericDefinition;
                if (field.definition == null) {
                    return null;
                }
                Debug.Assert(field.definition is FieldDefinition);
                var fieldDefinition = (FieldDefinition)field.definition;
                int index = Array.IndexOf(fieldDefinition.references, field);
                Debug.Assert(index >= 0);
                for (var variable = fieldDefinition.variables; variable != null; variable = variable.next, index--) {
                    if (index == 0) {
                        return variable;
                    }
                }
                throw new Unreachable();
            }
        }

        ///// <summary>
        ///// 判断或设置当前字段是否已被使用。
        ///// </summary>
        //public bool isEverUsed {
        //    get {
        //        var c = variable;
        //        return c == null || c.isEverUsed;
        //    }
        //    set {
        //        var c = variable;
        //        if (c != null) {
        //            c.isEverUsed = value;
        //        }
        //    }
        //}

        ///// <summary>
        ///// 判断或设置当前字段是否有被赋值。
        ///// </summary>
        //public bool isEverAssigned {
        //    get {
        //        var c = variable;
        //        return c == null || c.isEverAssigned;
        //    }
        //    set {
        //        var c = variable;
        //        if (c != null) {
        //            c.isEverAssigned = value;
        //        }
        //    }
        //}

        /// <summary>
        /// 判断当前成员是否重写了目标成员。
        /// </summary>
        /// <param name="other">被重写的目标成员。</param>
        /// <returns>如果成员被重写返回 true。</returns>
        public override bool isOverriding(MemberReference other) {
            return true;
        }

        /// <summary>
        /// 填充当前成员相关的泛型并返回新类型。
        /// </summary>
        /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
        /// <returns>返回填充后的新成员。</returns>
        public override MemberReference inflateMember(MemberReference genericMember) {
            var result = (FieldReference)MemberwiseClone();
            result.returnType = returnType.inflate(genericMember);
            return result;
        }

    }

    /// <summary>
    /// 表示一个属性引用。
    /// </summary>
    public partial class PropertyReference : TypeMemberReference {

        /// <summary>
        /// 获取当前成员的类型。
        /// </summary>
        public override MemberType memberType {
            get {
                return MemberType.property;
            }
        }

        /// <summary>
        /// 获取当前属性的 get 访问器。
        /// </summary>
        public MethodReference getAccessor;

        /// <summary>
        /// 获取当前属性的 set 访问器。
        /// </summary>
        public MethodReference setAccessor;

        /// <summary>
        /// 判断当前成员是否重写了目标成员。
        /// </summary>
        /// <param name="other">被重写的目标成员。</param>
        /// <returns>如果成员被重写返回 true。</returns>
        public override bool isOverriding(MemberReference other) {
            return true;
        }

        /// <summary>
        /// 填充当前成员相关的泛型并返回新类型。
        /// </summary>
        /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
        /// <returns>返回填充后的新成员。</returns>
        public override MemberReference inflateMember(MemberReference genericMember) {
            var result = (PropertyReference)MemberwiseClone();
            result.returnType = returnType.inflate(genericMember);
            return result;
        }

    }

    /// <summary>
    /// 表示一个索引器引用。
    /// </summary>
    public partial class IndexerReference : PropertyReference {

        /// <summary>
        /// 获取当前成员的类型。
        /// </summary>
        public override MemberType memberType {
            get {
                return MemberType.indexer;
            }
        }

        /// <summary>
        /// 获取当前索引器的参数。
        /// </summary>
        public new Parameter[] parameters;

        /// <summary>
        /// 将当前成员的签名写入字符串缓存。
        /// </summary>
        /// <param name="buffer">用于写入的缓冲区对象。</param>
        public override void writeSignature(StringBuilder buffer) {

            if (container != null && container.name != null) {
                container.writeSignature(buffer);
                buffer.Append('.');
            }

            buffer.Append("this");
            buffer.Append('[');
            TypeMemberReference.writeParameters(parameters, buffer);
            buffer.Append(']');
        }

        /// <summary>
        /// 判断当前成员是否重写了目标成员。
        /// </summary>
        /// <param name="other">被重写的目标成员。</param>
        /// <returns>如果成员被重写返回 true。</returns>
        public override bool isOverriding(MemberReference other) {
            return memberType != other.memberType || hasSameParameters(parameters, ((IndexerReference)other).parameters);
        }

        /// <summary>
        /// 填充当前成员相关的泛型并返回新类型。
        /// </summary>
        /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
        /// <returns>返回填充后的新成员。</returns>
        public override MemberReference inflateMember(MemberReference genericMember) {
            var result = (IndexerReference)MemberwiseClone();
            result.returnType = returnType.inflate(genericMember);
            result.parameters = infalteParameters(parameters, genericMember);
            return result;
        }

    }

    /// <summary>
    /// 表示一个函数（如方法、构造器、操作符重载、索引器）引用。
    /// </summary>
    public partial class MethodReference : TypeMemberReference {

        MemberType _memberType;

        /// <summary>
        /// 获取当前成员的类型。
        /// </summary>
        public sealed override MemberType memberType {
            get {
                return _memberType;
            }
        }

        /// <summary>
        /// 初始化 <see cref="MethodReference"/> 类的新实例。
        /// </summary>
        /// <param name="memberType">当前成员的类型。</param>
        public MethodReference(MemberType memberType) {
            Debug.Assert(memberType == MemberType.method ||
                memberType == MemberType.constructor || memberType == MemberType.@operator);
            _memberType = memberType;
        }

        /// <summary>
        /// 获取当前函数的参数列表。
        /// </summary>
        public new Parameter[] parameters;

        /// <summary>
        /// 将当前成员的签名写入字符串缓存。
        /// </summary>
        /// <param name="buffer">用于写入的缓冲区对象。</param>
        public override void writeSignature(StringBuilder buffer) {

            if (container != null && container.name != null) {
                container.writeSignature(buffer);
                buffer.Append('.');
            }

            switch (_memberType) {
                case MemberType.method:
                    // 名字为 $，需要处理 ?
                    buffer.Append(name);
                    break;
                case MemberType.constructor:
                    buffer.Append(container.name);
                    break;
                case MemberType.@operator:
                    buffer.Append("this ");
                    buffer.Append(name.Substring(1));
                    break;
            }

            buffer.Append('(');
            TypeMemberReference.writeParameters(parameters, buffer);
            buffer.Append(')');
        }

        /// <summary>
        /// 判断当前成员是否重写了目标成员。
        /// </summary>
        /// <param name="other">被重写的目标成员。</param>
        /// <returns>如果成员被重写返回 true。</returns>
        public override bool isOverriding(MemberReference other) {
            return memberType != other.memberType || (TypeMemberReference.hasSameParameters(parameters, ((MethodReference)other).parameters) && base.hasSameGenericParameterCount(other));
        }

        /// <summary>
        /// 填充当前成员相关的泛型并返回新类型。
        /// </summary>
        /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
        /// <returns>返回填充后的新成员。</returns>
        public override MemberReference inflateMember(MemberReference genericMember) {
            var result = (MethodReference)MemberwiseClone();
            result.returnType = returnType.inflate(genericMember);
            result.parameters = infalteParameters(parameters, genericMember);
            return result;
        }
    }

    /// <summary>
    /// 表示一个泛型方法引用。
    /// </summary>
    public partial class GenericMethodDefinitionReference : MethodReference {

        /// <summary>
        /// 当前成员的泛型形参。
        /// </summary>
        GenericParameter[] _genericParameters;

        /// <summary>
        /// 获取当前成员的泛型形参。如果当前成员不是泛型定义，则返回 null。
        /// </summary>
        public override GenericParameter[] genericParameters {
            get {
                return _genericParameters;
            }
        }

        /// <summary>
        /// 将当前成员的签名写入字符串缓存。
        /// </summary>
        /// <param name="buffer">用于写入的缓冲区对象。</param>
        public override void writeSignature(StringBuilder buffer) {
            if (container != null && container.name != null) {
                container.writeSignature(buffer);
                buffer.Append('.');
            }
            buffer.Append(name);
            buffer.Append("<");
            for (int i = 0; i < _genericParameters.Length; i++) {
                _genericParameters[i].writeSignature(buffer);
                buffer.Append(", ");
            }
            buffer[buffer.Length - 2] = '>';
            buffer[buffer.Length - 1] = '(';
            TypeMemberReference.writeParameters(parameters, buffer);
            buffer.Append(')');
        }

        /// <summary>
        /// 初始化 <see cref="GenericMethodDefinitionReference"/> 类的新实例。
        /// </summary>
        /// <param name="genericParameters">当前成员的泛型形参。</param>
        public GenericMethodDefinitionReference(MemberReference.GenericParameter[] genericParameters)
            : base(MemberType.method) {
            _genericParameters = genericParameters;
            base.initGenericParameters(genericParameters);
        }

        /// <summary>
        /// 填充当前成员相关的泛型并返回新类型。
        /// </summary>
        /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
        /// <returns>返回填充后的新成员。</returns>
        public override MemberReference inflateMember(MemberReference genericMember) {
            var result = (GenericMethodDefinitionReference)base.inflateMember(genericMember);
            result._genericParameters = MemberReference.inflateGenericParameters(_genericParameters, genericMember);
            return result;
        }

        private Dictionary<TypeReference[], MethodReference> _makedGenericMethods;

        /// <summary>
        /// 基于当前泛型定义创建新的方法。
        /// </summary>
        /// <param name="genericArguments">要使用的泛型实参。</param>
        /// <returns>返回新的泛型成员。</returns>
        public MethodReference makeGenericMethod(params TypeReference[] genericArguments) {

            MethodReference genericMethod;
            if (_makedGenericMethods == null) {
                _makedGenericMethods = new Dictionary<TypeReference[], MethodReference>(TypeReferenceArrayComparer.@default);
            } else if (_makedGenericMethods.TryGetValue(genericArguments, out genericMethod)) {
                return genericMethod;
            }

            return _makedGenericMethods[genericArguments] = genericMethod = new GenericMethodReference(this, genericArguments);

        }

    }

    /// <summary>
    /// 表示一个泛型方法引用。
    /// </summary>
    public partial class GenericMethodReference : MethodReference {

        /// <summary>
        /// 当前类型的泛型定义。
        /// </summary>
        private MethodReference _genericDefinition;

        /// <summary>
        /// 获取当前成员的泛型定义。如果当前成员不是泛型定义，则返回自身。
        /// </summary>
        public override MemberReference genericDefinition {
            get {
                return _genericDefinition;
            }
        }

        /// <summary>
        /// 当前成员的泛型实参。
        /// </summary>
        TypeReference[] _genericArguments;

        /// <summary>
        /// 获取当前成员的泛型实参。如果当前成员不是泛型，则返回 null。
        /// </summary>
        public override TypeReference[] genericArguments {
            get {
                return _genericArguments;
            }
        }

        /// <summary>
        /// 将当前成员的签名写入字符串缓存。
        /// </summary>
        /// <param name="buffer">用于写入的缓冲区对象。</param>
        public override void writeSignature(StringBuilder buffer) {
            if (container != null && container.name != null) {
                container.writeSignature(buffer);
                buffer.Append('.');
            }
            buffer.Append(name);
            buffer.Append("<");
            for (int i = 0; i < _genericArguments.Length; i++) {
                _genericArguments[i].writeSignature(buffer);
                buffer.Append(", ");
            }
            buffer[buffer.Length - 2] = '>';
            buffer[buffer.Length - 1] = '(';
            TypeMemberReference.writeParameters(parameters, buffer);
            buffer.Append(')');
        }

        /// <summary>
        /// 初始化 <see cref="GenericMethodReference"/> 类的新实例。
        /// </summary>
        /// <param name="genericArguments">当前成员的泛型实参。</param>
        public GenericMethodReference(MethodReference genericDefinitionMethod, TypeReference[] genericArguments)
            : base(MemberType.method) {
            setDefinition(genericDefinitionMethod);
            _genericArguments = genericArguments;
        }

        private void setDefinition(MethodReference genericDefinitionMethod) {
            _genericDefinition = genericDefinitionMethod;
            container = genericDefinitionMethod.container;
            definition = genericDefinitionMethod.definition;
            modifiers = genericDefinitionMethod.modifiers;
            name = genericDefinitionMethod.name;
            returnType = genericDefinitionMethod.returnType.inflate(this);
            parameters = infalteParameters(genericDefinitionMethod.parameters, this);
        }

        /// <summary>
        /// 填充当前成员相关的泛型并返回新类型。
        /// </summary>
        /// <param name="genericMember">包含要使用的泛型实参信息的泛型成员。</param>
        /// <returns>返回填充后的新成员。</returns>
        public override MemberReference inflateMember(MemberReference genericMember) {
            // 泛型定义不替换。
            throw new Unreachable();
        }

    }

    #endregion

}
